#!/usr/bin/env python3
"""
perl-File-MimeInfo MCP Server

面向 perl-File-MimeInfo 软件，提供 mimeopen 和 mimetype 命令行工具的 MCP 封装。

MCP tools 列表：
1. mimeopen_with_options - 使用 mimeopen 打开文件并支持各种交互选项
2. mimeopen_info_commands - 获取 mimeopen 的帮助、版本等信息
3. mimetype_basic_detection - 使用 mimetype 进行基本的 MIME 类型检测
4. mimetype_advanced_options - 使用 mimetype 的高级选项进行检测
5. mimetype_detection_modes - 使用 mimetype 的不同检测模式
6. mimetype_output_formats - 使用 mimetype 的不同输出格式

所有工具返回统一的 JSON 结构：
{
  "success": bool,
  "command": str,
  "exit_code": int,
  "stdout": str,
  "stderr": str
}
"""

import subprocess
import json
from typing import List, Optional
from mcp.server.fastmcp import FastMCP, Context

mcp = FastMCP("perl-File-MimeInfo MCP Server")

@mcp.tool()
def mimeopen_with_options(
    file_path: str,
    ask: bool = False,
    ask_default: bool = False,
    no_ask: bool = False,
    magic_only: bool = False,
    database: Optional[str] = None,
    debug: bool = False
) -> dict:
    """
    使用 mimeopen 打开文件，支持各种交互选项
    
    参数:
        file_path: 要打开的文件路径
        ask: 是否询问使用哪个应用程序 (对应 -a/--ask)
        ask_default: 是否询问默认应用程序 (对应 -d/--ask-default)
        no_ask: 是否不询问直接打开 (对应 -n/--no-ask)
        magic_only: 是否仅使用 magic 检测 (对应 -M/--magic-only)
        database: 指定 MIME 数据库路径 (对应 --database/-D)
        debug: 是否启用调试模式 (对应 --debug)
    
    返回:
        JSON 结构包含命令执行结果
    """
    cmd = ["mimeopen"]
    
    if ask:
        cmd.append("-a")
    elif ask_default:
        cmd.append("-d")
    elif no_ask:
        cmd.append("-n")
    
    if magic_only:
        cmd.append("-M")
    
    if database:
        cmd.extend(["--database", database])
    
    if debug:
        cmd.append("--debug")
    
    cmd.append(file_path)
    
    command_str = " ".join(cmd)
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=30
        )
        
        return {
            "success": result.returncode == 0,
            "command": command_str,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command_str,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def mimeopen_info_commands(
    command_type: str
) -> dict:
    """
    获取 mimeopen 的帮助、版本等信息
    
    参数:
        command_type: 命令类型，可选值: "help", "usage", "version", "debug"
    
    返回:
        JSON 结构包含命令执行结果
    """
    cmd = ["mimeopen"]
    
    if command_type == "help":
        cmd.extend(["--help"])
    elif command_type == "usage":
        cmd.extend(["--usage"])
    elif command_type == "version":
        cmd.extend(["--version"])
    elif command_type == "debug":
        cmd.extend(["--debug"])
    else:
        return {
            "success": False,
            "command": "",
            "exit_code": -1,
            "stdout": "",
            "stderr": f"Unknown command type: {command_type}"
        }
    
    command_str = " ".join(cmd)
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=10
        )
        
        return {
            "success": result.returncode == 0,
            "command": command_str,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command_str,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def mimetype_basic_detection(
    file_path: str,
    all_matches: bool = False,
    brief: bool = False,
    database: Optional[str] = None,
    describe: bool = False,
    debug: bool = False
) -> dict:
    """
    使用 mimetype 进行基本的 MIME 类型检测
    
    参数:
        file_path: 要检测的文件路径
        all_matches: 是否显示所有匹配的 MIME 类型 (对应 -a/--all)
        brief: 是否仅显示 MIME 类型 (对应 -b/--brief)
        database: 指定 MIME 数据库路径 (对应 --database)
        describe: 是否显示文件描述 (对应 -d/--describe)
        debug: 是否启用调试模式 (对应 -D/--debug)
    
    返回:
        JSON 结构包含命令执行结果
    """
    cmd = ["mimetype"]
    
    if all_matches:
        cmd.append("-a")
    elif brief:
        cmd.append("-b")
    
    if database:
        cmd.extend(["--database", database])
    
    if describe:
        cmd.append("-d")
    
    if debug:
        cmd.append("-D")
    
    cmd.append(file_path)
    
    command_str = " ".join(cmd)
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=10
        )
        
        return {
            "success": result.returncode == 0,
            "command": command_str,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command_str,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def mimetype_advanced_options(
    file_path: str,
    namefile: Optional[str] = None,
    file_compat: bool = False,
    separator: Optional[str] = None,
    command_type: Optional[str] = None
) -> dict:
    """
    使用 mimetype 的高级选项进行检测
    
    参数:
        file_path: 要检测的文件路径
        namefile: 从文件读取文件名列表 (对应 -f/--namefile)
        file_compat: 使用文件兼容模式 (对应 --file-compat)
        separator: 指定输出分隔符 (对应 -F/--separator)
        command_type: 命令类型，可选值: "help", "usage", "version"
    
    返回:
        JSON 结构包含命令执行结果
    """
    cmd = ["mimetype"]
    
    if namefile:
        cmd.extend(["-f", namefile])
    
    if file_compat:
        cmd.append("--file-compat")
    
    if separator:
        cmd.extend(["-F", separator])
    
    if command_type == "help":
        cmd.append("--help")
    elif command_type == "usage":
        cmd.append("--usage")
    elif command_type == "version":
        cmd.append("-v")
    
    if not command_type:
        cmd.append(file_path)
    
    command_str = " ".join(cmd)
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=10
        )
        
        return {
            "success": result.returncode == 0,
            "command": command_str,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command_str,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def mimetype_detection_modes(
    file_path: str,
    mimetype_only: bool = False,
    dereference: bool = False,
    language: Optional[str] = None,
    magic_only: bool = False,
    no_filename: bool = False,
    version: bool = False
) -> dict:
    """
    使用 mimetype 的不同检测模式
    
    参数:
        file_path: 要检测的文件路径
        mimetype_only: 仅显示 MIME 类型 (对应 -i/--mimetype)
        dereference: 解引用符号链接 (对应 -L/--dereference)
        language: 指定语言 (对应 -l/--language)
        magic_only: 仅使用 magic 检测 (对应 -M/--magic-only)
        no_filename: 不显示文件名 (对应 -N)
        version: 显示版本信息 (对应 --version)
    
    返回:
        JSON 结构包含命令执行结果
    """
    cmd = ["mimetype"]
    
    if version:
        cmd.append("--version")
        command_str = " ".join(cmd)
        try:
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                timeout=10
            )
            
            return {
                "success": result.returncode == 0,
                "command": command_str,
                "exit_code": result.returncode,
                "stdout": result.stdout,
                "stderr": result.stderr
            }
        except Exception as e:
            return {
                "success": False,
                "command": command_str,
                "exit_code": -1,
                "stdout": "",
                "stderr": str(e)
            }
    
    if mimetype_only:
        cmd.append("-i")
    elif dereference:
        cmd.append("-L")
    
    if language:
        cmd.extend(["-l", language])
    
    if magic_only:
        cmd.append("-M")
    
    if no_filename:
        cmd.append("-N")
    
    cmd.append(file_path)
    
    command_str = " ".join(cmd)
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=10
        )
        
        return {
            "success": result.returncode == 0,
            "command": command_str,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command_str,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def mimetype_output_formats(
    file_path: Optional[str] = None,
    stdin_input: Optional[str] = None,
    noalign: bool = False,
    output_format: Optional[str] = None
) -> dict:
    """
    使用 mimetype 的不同输出格式
    
    参数:
        file_path: 要检测的文件路径
        stdin_input: 从标准输入读取内容进行检测
        noalign: 不对齐输出 (对应 --noalign)
        output_format: 指定输出格式 (对应 --output-format)
    
    返回:
        JSON 结构包含命令执行结果
    """
    cmd = ["mimetype"]
    
    if noalign:
        cmd.append("--noalign")
    
    if output_format:
        cmd.extend(["--output-format", output_format])
    
    if stdin_input:
        cmd.append("--stdin")
        command_str = " ".join(cmd)
        try:
            result = subprocess.run(
                cmd,
                input=stdin_input,
                capture_output=True,
                text=True,
                timeout=10
            )
            
            return {
                "success": result.returncode == 0,
                "command": command_str,
                "exit_code": result.returncode,
                "stdout": result.stdout,
                "stderr": result.stderr
            }
        except Exception as e:
            return {
                "success": False,
                "command": command_str,
                "exit_code": -1,
                "stdout": "",
                "stderr": str(e)
            }
    else:
        if file_path:
            cmd.append(file_path)
        
        command_str = " ".join(cmd)
        try:
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                timeout=10
            )
            
            return {
                "success": result.returncode == 0,
                "command": command_str,
                "exit_code": result.returncode,
                "stdout": result.stdout,
                "stderr": result.stderr
            }
        except Exception as e:
            return {
                "success": False,
                "command": command_str,
                "exit_code": -1,
                "stdout": "",
                "stderr": str(e)
            }

if __name__ == "__main__":
    mcp.run()